home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / os2 / ext2_200.zip / EXT2_SRC.ZIP / 32BITS / EXT2-OS2 / FSD32 / FS32_RMD.C < prev    next >
C/C++ Source or Header  |  1996-09-21  |  5KB  |  147 lines
  1. //
  2. // $Header: D:/32bits/ext2-os2/fsd32/RCS/fs32_rmdir.c,v 1.1 1996/09/21 22:25:43 Willm Exp Willm $
  3. //
  4.  
  5. // 32 bits Linux ext2 file system driver for OS/2 WARP - Allows OS/2 to
  6. // access your Linux ext2fs partitions as normal drive letters.
  7. // Copyright (C) 1995, 1996 Matthieu WILLM
  8. //
  9. // This program is free software; you can redistribute it and/or modify
  10. // it under the terms of the GNU General Public License as published by
  11. // the Free Software Foundation; either version 2 of the License, or
  12. // (at your option) any later version.
  13. //
  14. // This program is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. // GNU General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public License
  20. // along with this program; if not, write to the Free Software
  21. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. #ifdef __IBMC__
  23. #pragma strings(readonly)
  24. #endif
  25.  
  26.  
  27. #define INCL_DOS
  28. #define INCL_DOSERRORS
  29. #define INCL_NOPMAPI
  30. #include <os2.h>
  31.  
  32. #include <string.h>
  33.  
  34. #include <os2/types.h>
  35. #include <os2/StackToFlat.h>
  36. #include <os2/fsd32.h>
  37. #include <os2/fsh32.h>
  38. #include <os2/DevHlp32.h>
  39.  
  40. #include <linux/stat.h>
  41.  
  42. #include <os2/os2proto.h>
  43. #include <os2/ifsdbg.h>
  44. #include <os2/filefind.h>
  45. #include <os2/errors.h>
  46. #include <os2/log.h>         /* Prototypes des fonctions de log.c                      */
  47. #include <os2/volume.h>      /* Prototypes des fonctions de volume.c                   */
  48. #include <os2/files.h>       /* Prototypes des fonctions de files.c                    */
  49. #include <os2/os2misc.h>
  50. #include <os2/trace.h>
  51.  
  52. #include <linux/fs.h>
  53. #include <linux/fs_proto.h>
  54. #include <linux/ext2_fs.h>
  55. #include <linux/ext2_proto.h>
  56. #include <linux/sched.h>
  57.  
  58. #define THISFILE FILE_FS_DIR_C
  59.  
  60. /*
  61.  * struct fs32_rmdir_parms {
  62.  *     unsigned short iCurDirEnd;
  63.  *     PTR16          pName;
  64.  *     PTR16          pcdfsd;
  65.  *     PTR16          pcdfsi;
  66.  * };
  67.  */
  68. int FS32ENTRY fs32_rmdir(struct fs32_rmdir_parms *parms) {
  69.     char           *pName;
  70.     struct cdfsi32 *pcdfsi;
  71.     union  cdfsd32 *pcdfsd;
  72.     int             rc;
  73.     struct super_block *sb;       /* volume descriptor */
  74.     struct inode       *dir;
  75.     struct file        *filp;
  76.     ino_t               ino_no;
  77.     char              parent[CCHMAXPATH];
  78.     char              name[CCHMAXPATH];
  79.     char             *__name = __StackToFlat(name);
  80.     umode_t                i_mode;
  81.     UINT32              mode;
  82.  
  83.  
  84.  
  85.     parms = __StackToFlat(parms);
  86.  
  87.     if ((rc = DevHlp32_VirtToLin(parms->pcdfsi, __StackToFlat(&pcdfsi))) == NO_ERROR) {
  88.         if ((rc = DevHlp32_VirtToLin(parms->pcdfsd, __StackToFlat(&pcdfsd))) == NO_ERROR) {
  89.             if ((rc = DevHlp32_VirtToLin(parms->pName, __StackToFlat(&pName))) == NO_ERROR) {
  90.             if (trace_FS_RMDIR) {
  91.                 kernel_printf("FS_RMDIR pre-invocation : %s", pName);
  92.             }
  93.  
  94.             if (Read_Write) {
  95.                 mode = (is_case_retensive() ? OPENMODE_DOSBOX : 0);
  96.                 //
  97.                 // Gets the superblock from pcdfsi
  98.                 //
  99.                 if ((sb = getvolume(pcdfsi->cdi_hVPB)) != 0) {
  100.  
  101.                     ExtractPath(pName, __StackToFlat(parent));
  102.                     ExtractName(pName, __StackToFlat(name));
  103.                     if ((filp = _open_by_name(sb, __StackToFlat(parent), OPENMODE_READONLY | mode)) != NULL) {
  104.                         ino_no = filp->f_inode->i_ino;
  105.                         i_mode = filp->f_inode->i_mode;
  106.                         if ((rc = vfs_close(filp)) == NO_ERROR) {
  107.  
  108.                             if (S_ISDIR(i_mode)) {
  109.                                    if (((i_mode & S_IWUSR)) ||
  110.                                     ((i_mode & S_IWGRP)) ||
  111.                                     ((i_mode & S_IWOTH))) {
  112.  
  113.                                     dir = iget(sb, ino_no);
  114.                                     rc = dir->i_op->rmdir(dir, __StackToFlat(name), strlen(__name));
  115.                                     rc = map_err(rc);        // rc was a Linux error code (from linux/errno.h)
  116.                                 } else {
  117.                                     kernel_printf("FS_RMDIR - %s is read only", pName);
  118.                                     rc = ERROR_ACCESS_DENIED;
  119.                                    }
  120.                             } else {
  121.                                 kernel_printf("FS_RMDIR - %s is not a directory", pName);
  122.                                 rc = ERROR_ACCESS_DENIED;
  123.                             }
  124.                         } else {
  125.                             fs_err(FUNC_FS_RMDIR, FUNC_CLOSE, rc, THISFILE, __LINE__);
  126.                         }
  127.                     } else {
  128.                         fs_err(FUNC_FS_RMDIR, FUNC_OPEN_BY_NAME, -1, THISFILE, __LINE__);
  129.                         rc = ERROR_OPEN_FAILED;
  130.                        } /* end if */
  131.                 } else {
  132.                     kernel_printf("FS_RMDIR - Couldn't get the superblock");
  133.                     rc = ERROR_INVALID_PARAMETER;
  134.                 }
  135.             } else {
  136.                 rc = ERROR_WRITE_PROTECT;
  137.             }
  138.  
  139.             if (trace_FS_RMDIR) {
  140.                 kernel_printf("FS_RMDIR post-invocation : rc = %d", rc);
  141.             }
  142.             }
  143.         }
  144.     }
  145.     return rc;
  146. }
  147.